# -*- coding: utf-8 -*-
from PyQt4 import QtGui
from PyQt4 import QtCore
from PyQt4.QtGui import *
from PyQt4.QtCore import *
from logico.problemas.acciones.IAccion import IAccion
from logico.iABJ import *
import os.path

class ABJLabel(QLabel):
    """ 
    Esta clase representa una de las uniones entre el emisferio logico y
    el emisferio grafico, especificamente la referida a los objetos logicos 
    (cuchara, carro, etc) y los objetos graficos (imagenes desplegadas)
    @since: 4/14/2011pon_show_panel
    @version: 1.0
    """
    
    _seleccionado = []
    """ Arreglo para controlar cual es el objeto logico seleccionado actualmente en el escenario"""
    
    _objeto = None
    """ Objeto logico representado por el label actual """
    
    _loLogico = None
    """ Variable de instancia que se refiere al objeto logico sobre el que esta """
    
    __grafico = None
    """ Variable de instancia de lo grafico """
    
    ___enMochila = False
    """ Variable para ver si se encuentra o no ligado el objeto """
    
    _heroe = False
    """ Verifica si es el Label de Heroe """
    
    def __init__(self, parent, ob, sel, logico, grafico=None, enMochila=False):
        """
        Constructor
        @type    self: ABJLabel
        @param    self: referencia al objeto ABJLabel actual
        
        @type    parent: Component
        @param    parent: Componente de pyQT que despliega el ABJLabel actual
        
        @type    ob: Objeto
        @param    ob: Objeto logico representado por ABJLabel actual.
        
        @type    sel: list
        @param    sel: arreglo que indica agrupaciones de objetos mutuamente excluyentes respecto de la seleccion.
        
        @type    logico: LogicoABJ
        @param    logico: referencia al objeto logico que controla el comportamiento de los elementos de la escena y problema.
        
        @type    grafico: ????
        @param    grafico: ????
        
        @type    enMochila: Boolean
        @param    enMochila: bandera para indicar si el objeto representado por el ABJLabel actual se encuentra en la mochila.
        """
        QLabel.__init__(self, parent)
        self._seleccionado = sel
        self._objeto = ob
        self._loLogico = logico
        self.__grafico = grafico
        self.__enMochila = enMochila
        self._heroe = False
        
    def set_heroe(self):
        self._heroe = True
        
    def dragEnterEvent(self, event):        
        event.accept()
        print "here"

    def dragLeaveEvent(self, event):
        event.accept()

    def dragMoveEvent(self, event):
        event.setDropAction(QtCore.Qt.MoveAction)
        event.accept()

    def dropEvent(self, event):
        event.setDropAction(QtCore.Qt.MoveAction)
        event.accept()
        print "drop label"        
        
    def mousePressEvent(self, event):
        while len(self._seleccionado) > 0:
            self._seleccionado.pop()
            
        # Seleccionar el objeto actual
        self._seleccionado.append(self._objeto)        
        if (event.button() == 1) and isinstance(self._objeto,ITener)== False and self._heroe == False:
            hotSpot = event.pos()
            mimeData = QtCore.QMimeData()
            pixmap = QtGui.QPixmap(self.size())
            self.render(pixmap)

            drag = QtGui.QDrag(self)
            drag.setMimeData(mimeData)
            drag.setPixmap(pixmap)
            drag.setHotSpot(hotSpot)

            dropAction = drag.exec_(QtCore.Qt.CopyAction | QtCore.Qt.MoveAction, QtCore.Qt.CopyAction)
            
            self.emit(SIGNAL('clicked()'))
            self.emit(SIGNAL('clickLabel'))
            
    

    def mouseReleaseEvent (self, ev):
        # Eliminar todos los objetos seleccionados
        while len(self._seleccionado) > 0:
            self._seleccionado.pop()
        
        # Seleccionar el objeto actual
        self._seleccionado.append(self._objeto)
        
        #Presiono click izquierdo??
        if(ev.button()==1):
        # Enviar el mensaje para indicar que hubo un clic
            self.emit(SIGNAL('clicked()'))
            
        
    #Overload del manejador del evento de ContextMenu al hacer click derecho    
    def contextMenuEvent(self, position):
        """
        Overload del manejador de evento de clic (release)
        @type    self: ABJLabel
        @param    self: referencia al objeto ABJLabel actual
        
        @type    position: QPoint
        @param    position: enviado por el sistema cuando el evento se dispara. Almacena las coordenadas (x,y) de donde se registro el clic.
        """
        menu = QMenu()
        #menu.addMenu("Menu de acciones")
        nombreObjeto=self._objeto.getNombre()
        
        actionsObjectsArray = self._loLogico._problema.getAcciones(nombreObjeto)
        
        if(self.__enMochila==False):
            #actionsArray.append('Agarrar')
            actionsObjectsArray.append(IAccion(verbo="Agarrar"))
            #actionsArray.append('Moverse a')
            actionsObjectsArray.append(IAccion(verbo="Moverse a", imagen="imagenes/acciones/Moverse a.png", comando="{verbo} {articulo0} {objeto0}", sinContenedor=True))
        else:
            #actionsArray.append('Soltar')
            actionsObjectsArray.append(IAccion("Soltar"))
            
        #Recorre arreglo de acciones del objeto
        for a in actionsObjectsArray:
            #Solamente muestra aquellas que cumplan con las reglas.
            if((a.enMochila()==None or self.__enMochila==a.enMochila()) and (a.sinContenedor()==None or not(self._objeto.estaContenido)== a.sinContenedor())):    
                newaction = menu.addAction(a.verbo+" "+a.objeto)
                newaction.setData(a)
                b=a.getImagen()
                icono = QtGui.QIcon()
                icono.addPixmap(QtGui.QPixmap(a.getImagen()),QtGui.QIcon.Normal, QtGui.QIcon.On)
                newaction.setIcon(icono)
                newaction.setIconVisibleInMenu(True)
                menu.addSeparator()
                
        action = menu.exec_(self.mapToGlobal(position))
        
        if not menu.isEmpty() and not(action==None):
            #es la accion de desligar?
            if(action.text().trimmed ().toLower()=='soltar' and self.__grafico<>None):
                self.__grafico.dligar()
            #es la accion de ligar?
            elif(action.text().trimmed ().toLower()=='agarrar' and self.__grafico<>None):
                self.__grafico.ligar()
            else:
                 
                action=action.data().toPyObject()
                #Es una acción heredable?
                if(action.esHeredable()):
                    nombreObjeto=action.objeto
                    
                action.articulos=[self._loLogico._articulo.get(self._loLogico._genero.get(nombreObjeto))]
                action.objetos=[nombreObjeto]
                
                executeAction=True
                
                if(action.esDesligar()):
                    if(len(self.__grafico._sele)==0):
                        executeAction=False
                        self.__grafico.errorDialog("Ten cuidado no puedes " + action.verbo + " " + action.articulos[0] + " " + action.objetos[0] + " sobre el piso.")
                    else:
                        action.articulos.append(self._loLogico._articulo.get(self._loLogico._genero.get(self.__grafico._sele[0].getNombre())))
                        action.objetos.append(self.__grafico._sele[0].getNombre())   
                
                if(executeAction):       
                    print (str(action.getComando()))
                    self._loLogico.runCommand(str(action.getComando()))
                    
                    if(self.__grafico<>None):
                        self.__grafico.refresca_grafico()
                            
                    #Crear item del log
                    self.__grafico.addLogItem(action)
                
                    self.emit(SIGNAL('clicked()'))
